גירסה C++ Tutorial Nir Adar עמוד 1

Transcription

1 גירסה C++ Tutorial מסמך זה הורד מהאתר. אין להפיץ מסמך זה במדיה כלשהי, ללא אישור מפורש מאת המחבר. מחבר המסמך איננו אחראי לכל נזק, ישיר או עקיף, שיגרם עקב השימוש במידע המופיע במסמך, וכן לנכונות התוכן של הנושאים המופיעים במסמך. עם זאת, המחבר עשה את מירב המאמצים כדי לספק את המידע המדויק והמלא ביותר. Nir Adar Home Page: כל הזכויות שמורות ל אנא שלחו תיקונים והערות אל המחבר. עמוד 1

2 עמוד 2

3 תוכן עניינים תוכן עניינים... 3 הקדמה... 4 הכרות ראשונה עם מחלקות... 5 הרשאות... 9 תרגיל קלט ופלט בשפת ++C פונקציות חופפות הקצאת זיכרון דינמית DEFAULT PARAMETERS משתני התייחסות הגדרת משתנים,...CONSTRUCTORS & DESTRUCTORS 21 הגדרת משתנים CONSTRUCTORS & DESTRUCTORS תחביר בסיסי ומוטיבציה מחלקות בעלות מספר בנאים, רשימות אתחול Default Constructor דוגמא מסכמת סיום עמוד 3

4 הקדמה במסמך זה נסקור את שפת ++C. מסמך זה מיועד לאנשים הבקיאים היטב בשפת C. המסמך אינו מתיימר להיות מדריך שלם לכל שפת ++C, אלא מיועד להעביר בצורה טובה את העקרונות והשיטות לגשת לתכנות ב++ C. מסמך זה הוא שדרוג של המסמך הישן שהיה בפרויקט,UnderWarrior והוא למעשה מצב ביניים של המטרה אליה אני שואף להגיע. בימים אלו אני משפר את המסמך על מנת שיהווה מדריך שלם לשפה. שינוי זה הולך לשנות את אופי המסמך, את סדר הנושאים בו, וכדו'. גירסה זו של המסמך היא הרחבה של המסמך המקורי שכתבתי, שעדיין שומרת על אופיו. לדעתי הזווית המצומצמת שמסמך זה מציג, גם לה יש מקום, ולכן אני משחרר מסמך זה כמסמך נפרד. אנשים רבים מתייחסים אל שפת ++C כהרחבה של שפת C. למעשה שפות אלו שונות ביותר אחת מהשניה. ++C היא שפה המציגה תפיסה חדשה ושונה לחלוטין מזו של שפת C. הסיבה להתייחסות לעתים לשפת ++C כהרחבה של C, היא הסיבה שכמעט כל תוכנה שנכתבה עבור C, תרוץ גם בשפת ++C. המקור הוא היסטורי מתכנני ++C רצו שיהיה ניתן להשתמש בקוד שכבר היה קיים בשפת C גם בשפה החדשה, ולכן תכננו אותה תואמת ככל הניתן לשפת C, בלי לפגוע בהגבלות וברעיונות של.C++ מדוע אם כך לא כל תוכנית בשפת C תרוץ בשפת ++C? הסיבה היא שבשפת ++C הוספו מילים שמורות (keywords) חדשות, שלמתכנת אסור להשתמש בהן בתור משתנים, כגון new, delete ועוד. תוכניות בשפת C בהן נעשה שימוש בשמות מזהים שב ++C הם מילים שמורות לא יעברו קומפילציה. במסמך זה נכיר את שפת ++C בעזרת מספר רב של דוגמאות. רוב הנושאים יוצגו בעזרת דוגמא, ולאחריה הסבר. הדגשנו במסמך את צורת החשיבה הדרושה לתכנות נכון ב ++C. במספר מקומות במסמך - ראשית אנו מציגים קטע קוד ב- C, מציגים בעייתיות הקיימת בו, ורואים כיצד הכלים השונים ב ++C פותרים את הבעיה הנדונה. עמוד 4

5 הכרות ראשונה עם מחלקות שפת ++C בנויה מסביב למחלקות.(class) מחלקה היא הרחבה של מושג המבנים (structs) הקיים בשפת C. מחלקה היא למעשה הגדרת טיפוס חדש בו מרוכזים פונקציות ומשתנים תחת שם אחד. לאחר שהגדרנו מחלקה, נוכל ליצור אובייקטים מסוג המחלקה שהגדרנו, ולהשתמש בהם בתוכניות שלנו. רעיון המחלקות הוא ניסיון לקרב את שפת התכנות למחשבה האנושית. אנו מגדירים עצמים ואוסף פעולות עליהם. למשל, נוכל להגדיר עצם מסוג בן אדם. נגדיר (בעזרת פונקציות) פעולות כגון הליכה, דיבור וכדומה. לאחר שהגדרנו אדם, נוכל להגדיר למשל גם זמר, שיקבל את כל התכונות של העצם אדם, ולהוסיף עליהן תכונות ופעולות נוספות, למשל, שירה. נראה במסמך זה כיצד אנו נעביר רעיונות כאלו ואחרים אל שפת התכנות. נתחיל בהכרת ++C, ונפתח בדוגמא: class MyClass int i; void func1(); int Start(); ; class Car int Drive(); ; class Horse int Drive(); ; MyClass a; Car Volvo; Horse Moshe; a.i = 3; a.func1(); Moshe.Drive(); Volvo.Drive(); עמוד 5

6 נביט בקטע מהדוגמא: class MyClass int i; void func1(); int Start(); ; התחלנו קטע זה בהגדרת מחלקה חדשה בשם.MyClass לאחר מכן, המילה השמורה public מגדירה את ההרשאות שיהיו למשתנים ולפונקציות שיופיעו אחריה. בנושא ההרשאות נעסוק מאוחר יותר. רק נציין שבדרך כלל לא נהוג להגדיר משתנים בשטח ה- public של המחלקה. כרגע כתבנו את המשתנה תחת ההרשאה public רק כדי לשמור על פשטות הדוגמא. לאחר מכן הגדרנו שהמחלקה MyClass מכילה משתנה בשם i מסוג,int ושתי פונקציות - func1() ו-() Start. נשים לב לנקודה הבאה: כאשר הגדרנו מחלקה, הגדרנו למעשה תבנית, ולא יצרנו משתנים. בדומה ל- struct בשפת C, כאשר מגדירים struct אנחנו לא מקצים זיכרון עבור המשתנים. הזיכרון יוקצה רק עבור כל משתנה שניצור מסוג ה- struct (ובמקרה שלנו עבור כל משתנה שניצור מסוג של המחלקה). צורת דיבור: כאשר, למשל, אנחנו כותבים את הקוד הבא: אנחנו אומרים שהגדרנו משתנה בשם i, שהסוג שלו הוא.int כאשר נגדיר משתנה שהוא מסוג מחלקה, נכנה את המשתנה בשם אובייקט. לדוגמא: בדוגמא זו יצרנו אובייקט בשם a שסוגו הוא המחלקה.MyClass int i; MyClass a; נזכור זאת להבא: כאשר מדברים על מחלקה, מדברים על התבנית שהגדרנו. כאשר מדברים על אובייקט, אנו מתייחסים לעותק של התבנית, הנמצא בזיכרון. class Car int Drive(); ; class Horse int Drive(); ; עמוד 6

7 בקטע קוד זה הגדרנו שתי מחלקות, אחת בשם Car והשניה בשם.Horse בכל אחת מהן קיימת פונקציה בשם.Drive() נשים לב שעבור כל מחלקה, יצרנו פונקציה Drive() שונה. בהצהרה זו הכרזנו על פונקציה Drive() ששייכת למחלקה Car ועל פונקציה.Horse ששייכת למחלקה Drive() MyClass a; Car Volvo; Horse Moshe; a.i = 3; a.func1(); Moshe.Drive(); Volvo.Drive(); כמו ב- C, הפונקציה ממנה מתחילה התוכנית לרוץ היא.main() עם תחילת התוכנית, אנו יוצרים אובייקט מסוג MyClass בשם a, אובייקט בשם.Moshe בשם Horse ואובייקט מסוג Car מסוג Volvo לאחר מכן, ניגשנו, בדומה לצורה בה אנו ניגשים לשדות ב- struct, אל השדה i הנמצא באובייקט a ושמנו בו את הערך 3. לאחר מכן קראנו לפונקציה func1() השייכת למחלקה MyClass על האובייקט a. כאשר השתמשנו פעמיים בפונקציה,Drive() פעם על Moshe ופעם על,Volvo קראנו לשתי פונקציות. בפעם הראשונה קראנו לפונקציה של המחלקה Horse ובפעם השניה קראנו לפונקציה של המחלקה.Car הערה: בדוגמא זו לא הצגנו כיצד ממשים את הפונקציות המוגדרות בתוך המחלקות, אלא רק כיצד מצהירים עליהן. נביט בדוגמא נוספת ונראה כיצד ניתן לממש פונקציות השייכות למחלקה. class Rectangle int x, y; int getarea() return x*y; ; class Circle int x, y, radius; int getarea(); ; עמוד 7

8 (אנו מניחים כי PI הוא קבוע שהוגדר במקום כלשהו בתוכנית). int Circle::getArea() return PI*radius*radius; ניתן לממש פונקציה בתוך הגדרת המחלקה, או לחילופין לממש אותה בקטע קוד נפרד מחוץ למחלקה. נביט במחלקה הראשונה בדוגמא: class Rectangle int x, y; int getarea() return x*y; ; הפונקציה getarea() ממומשת מיד אחרי ההצהרה עליה. היא מחזירה את המכפלה של x ב- y. נשים לב לדוגמא לשימוש בפונקציה: Rectangle rec1, rec2; int area1, area2;... area1 = rec1.getarea(); area2 = rec2.getarea(); בקריאה הראשונה הפונקציה פעלה על ה- x וה- y השייכים ל- rec1 ובקריאה השני היא פעלה על אלו השייכים ל- rec2. כעת נביט בצורה השניה למימוש פונקציות: class Circle int x, y, radius; int getarea(); ; int Circle::getArea() return PI*radius*radius; בדוגמא זו הצהרנו על הפונקציה getarea() בתוך המחלקה,Circle ומימשנו אותה מחוץ למחלקה. הכוונה בצורת הכתיבה הבאה: Circle::getArea() היא שאנו מממשים את הפונקציה getarea ששייכת למחלקה.Circle כבר ראינו שאותו שם לפונקציה יכול לשמש במחלקות שונות. לכן כשאנו באים לממש את הפונקציה מחוץ למחלקה, אנו צריכים להגיד במפורש לאיזו מחלקה פונקציה זו שייכת. עמוד 8

9 הרשאות כאשר עבדנו בשפת C, עבדנו לעיתים קרובות על ידי הגדרת ADTs Abstract -.Data Types הרעיון היה כזה: הגדרנו מבנה נתונים (struct) ואז הגדרנו פונקציות שפעלו עליו, והיו למעשה פעולות שמיועדות למבנה הנתונים שיצרנו. ב++ C למעשה הפכנו את מודל מבנה הנתונים המופשט לחלק מהשפה. כאשר אנו שמים למעשה את הפונקציות בהגדרת המחלקה אנחנו אומרים: הפונקציה X הנמצאת במחלקה Y, שייכת למחלקה Y, והיא תעבוד על אובייקטים הנמצאים במחלקה. יתכן ש- X תקבל פרמטרים ויתכן שלא, אולם תהיה לה גישה בכל מקרה לאובייקט עליו היא פועלת. למשל, בדוגמא הקודמת, כאשר כתבנו Moshe.Drive() הפעלנו את הפונקציה Drive() על האובייקט,Moshe מבלי להעביר את Moshe כפרמטר. בצורה זו ++C מחברת את רעיון ה- ADT לשפה. אחת הבעיות הגדולות שהיו עם,ADT היא שלמרות שהגדרנו פונקציות בהן המשתמש צריך להשתמש כדי לעבוד עם מבנה הנתונים שיצרנו, לא הייתה מניעה שהוא ייגש ישירות למשתנים וישנה אותם. במקרה כזה, יתכן שהאובייקט היה מגיע למצב לא תקף בעקבות שינויי המשתמש, והפונקציות שיועדו לפעול עליו היו נכשלות. בעיה נוספת, גדולה אף יותר, היא שבכך שהמשתמש ניגש ישירות לשדות של מבנה הנתונים, הוא נעשה תלוי במימוש של מבנה הנתונים. שינוי במימוש במקרה כזה ידרוש שינוי בקוד שהתבסס עליו. ++C באה לעזור לנו במקרה זה. מנגנון ההרשאות ב++ C בא למנוע מהמשתמש לגשת לחלק מהשדות של מבנה הנתונים, שלא בעזרת הפונקציות שמתכנת המחלקה בחר. ישנם 3 סוגי הרשאות ב++ C : private,public ו- protected. נציג כעת את שני הסוגים הראשונים, ובהרשאה מסוג protected ניתקל עוד בהמשך. class permissionclass int inumber1; private: int inumber2; ; permissionclass per; per.inumber1 = 10; per.inumber2 = 10; עמוד 9

10 הרשאה מסוג public היא ההרשאה שראינו עד כה. הרשאה זו אומרת: כל אחד יכול לגשת למשתנה או לפונקציה המוגדרת כ- public ולעשות בעזרתה ככל העולה על רוחו. לעומתה, הרשאה מסוג private אומרת: אל המשתנים או הפונקציות המוגדרים כ- private, יוכלו לגשת רק פונקציות השייכות לאותה מחלקה. בדרך כזו נוכל להפריד בין הממשק אל המשתמש לבין המימוש של המחלקה: הממשק יהיה בחלק ה- public של המחלקה, ופונקציות ומשתנים הקשורים למימוש יהיו ב- private. בדוגמא לעיל, ;10 = per.inumber1 היא שורה חוקית, כי inumber1 נמצא תחת ההרשאה public במחלקה. לעומתה, השורה ;10 = per.inumber2 איננה שורה חוקית, כי inumber2 איננו נמצא בחלק ה- public של המחלקה. שורה זו לא תעבור כלל קומפילציה. נביט בדוגמא נוספת, ונתחיל לראות כיצד משתמשים בהרשאות השונות. #include <iostream.h> class MyClass private: int j; int func1(int i); void print() cout << j << endl; ; int MyClass::func1(int i) j = i; return j; MyClass class1, class2; // The following line is illegal: class1.j = 10; class1.func1(10); class2.func1(20); class1.print(); class2.print(); הספרייה iostream.h היא המחליפה של הספרייה stdio.h משפת C, והיא מכילה מחלקות שונות לקלט ופלט. הפונקציה print הממומשת בתוך המחלקה MyClass משתמשת באובייקט cout על מנת לשלוח פלט למסך, ולכן היינו צריכים לעשות include לספריה זו. עמוד 10

11 השימוש באובייקט cout זוהי הדרך שלנו בשפת ++C לשלוח פלט למסך. C. של הוא המחליף ל' n \' endl ב- MyClass יצרנו משתנה עם הרשאה private בשם j. כמו כן יצרנו את הפונקציה print() שמדפיסה את ערכו, וכן יצרנו פונקציה בשם func1() שמקבלת מספר ומחליפה את ערכו של j במספר זה. התוכנית מדגימה כיצד אנו יוצרים שני אובייקטים מסוג.MyClass איננו יכולים להציב לתוך המשתנה j בתוך כל אחד מהם ערכים ישירות, (עקב ההרשאה שנתנו למשתנה זה), לכן אנו משתמשים בפונקציה func1() כדי לקבוע את ערכי j. בתחילה תהליך זה נראה מסורבל משהו, הרי בסופו של דבר בכל מקרה אנו משנים את המשתנה j, אז למה לעשות את זה דרך פונקציה ולא ישירות? יש לכך שתי סיבות חשובות: סיבה ראשונה, המוכרת למתכנתי C שעבדו עם,ADT היא הצורך להפריד בין הממשק של התוכנית למימוש שלה. הפונקציה func1() שייכת ל- public של הפונקציה, כלומר לממשק. אנו מניחים שכאשר קוראים לה היא משנה משתנה בתוך המחלקה, וכאשר קוראים ל-() print משתנה זה מודפס. אם המשתמש משתמש רק בפונקציות אלו ולא ניגש ישירות ל- j, נוכל למשל לשנות את שם המשתנה j, או לשנות פרטי אחרים הקשורים למימוש, ותוכניתו של המשתמש במחלקה לא תושפע. לעומת זאת אם המשתמש במחלקה ניגש ישירות לשדות שלה ואז נשנה את המחלקה, גם תוכניות המשתמש ידרשו שינוי. סיבה שניה, חשובה לא פחות להרשאות, היא ביקורת על המידע. נניח שנרצה לכתוב מחלקה שתתאר אדם. class Person private: char *name; int age; void SetAge(int newage); ; נרצה להיות מסוגלים לשנות את גילו של האדם. פתרון אפשרי יכול להיות הפונקציה הבאה: void Person::SetAge(int newage) age = newage; עמוד 11

12 אולם, נוכל גם להציע את הפתרון הבא: void Person::SetAge(int newage) if (newage > 0) age = newage; כאן אנו מתחילים לראות את היתרון שמשתנה private נתן לנו. פונקציה זו משנה את גילו של האדם רק אם הגיל החדש שרוצים לקבוע לו גדול מ- 0, כי הרי לא אפשרי שלאדם יהיה גיל שלילי. מכיוון שכל שינוי של המשתנה age צריך לעבור דרך הפונקציה,SetAge() אנו יכולים לבדוק ולהיות בטוחים שגילו של האדם הוא גיל תקף כל הזמן. נושא שיכול לבלבל בהתחלה הוא מתי ראוי להשתמש בכל אחת מההרשאות. האם המשתנה יכול להיות?private?public ומה לגבי פונקציות? מה לגבי ההרשאה הנוספת שאמרנו שקיימת,?protected הכלל הבא יסכם את הנושא: כלל אצבע לגבי הרשאות משתני המחלקה יוגדרו תמיד בתור.private פונקציות הנגישות למשתמש יוגדרו,public ופונקציות פנימיות ימוקמו לרוב כ- private. המשתמש אף פעם אינו צריך לגשת אל משתני המחלקה. אלו שייכים למימוש ולכן נמקם אותם כפרטיים. לכל משתנה שהוא,private במידה ונרצה לתת למשתמש גישה אליו, נגדיר פונקציה שתחזיר את ערכו למשתמש (get) ופונקציה שתאפשר למשתמש להזין ערך חדש עבור המשתנה.(set) תרגיל כתוב מחלקה בשם Point המייצגת נקודה במישור. לנקודה ערכי x ו- y שלמים אותם ניתן לקבל ולקבוע. כמו כן ניתן לקבל את מרחק הנקודה מהראשית. פתרון לתרגיל מוצג בעמוד הבא. עמוד 12

13 פתרון אפשרי לתרגיל: #include <math.h> class Point int GetX(); int GetY(); void SetX(int new_x) x = new_x; ; void SetY(int new_y) y = new_y; ; ; double Length(); private: int x, y; int Point::GetX() return x; int Point::GetY() return y; double Point::Length() return sqrt(x*x+y*y); יש לציין כי מימוש נכון ומלא של מחלקה זו הינו שונה מעט מהפתרון המוצג לעיל. הפתרון המוצע מתבסס על הידע אותו הצגנו עד כה במסמך. עמוד 13

14 קלט ופלט בשפת ++C נציג מספר דוגמאות נוספות לשימוש ב- cout, אוביקט המאפשר גישה אל הפלט של שפת ++C. נניח למשל שנרצה להדפיס שלושה מספרים אחד אחרי השני, נוכל לכתוב את הקוד הבא: על המסך יודפס: "456". אם נרצה להדפיס גם רווחים בין המספרים, נעשה זאת כך: או כך: int x = 4, y = 5, z = 6; cout << x << y << z; int x = 4, y = 5, z = 6; cout << x << " " << y << " " << z; int x = 4, y = 5, z = 6; cout << x << ' ' << y << ' ' << z; נסכם: האובייקט cout שולח פלט אל הפלט הסטנדרטי. ניתן לשרשר מספר איברים להדפסה, ולהדפיסם בשימוש אחד באובייקט,cout על ידי שימוש באופרטור >> בין איבר לאיבר. האובייקט cout מזהה את סוגי המשתנים שנשלחים אליו. אין צורך להעביר (כמו ב-() printf ב- C ) מהו הסוג של כל משתנה אותו רוצים להדפיס. שפת ++C מאפשרת לנו את התנהגותו של האופרטור >> כך שנוכל בעזרת cout להדפיס גם אובייקטים מסוג של מחלקות שאנו ניצור. קלט בשפת ++C מתבצע על ידי האובייקט,cin וצורת השימוש בו מזכירה קצת את השימוש ב- cout. הקוד הבא, לדוגמא, קולט מספר שלם מן המשתמש לתוך המשתנה i: int i; cin >> i; עמוד 14

15 פונקציות חופפות אחת מההרחבות של ++C לשפת C, היא הוספת פונקציות חופפות לשפה. בשפת ++C ניתן להגדיר פונקציות בעלות אותו שם, אך בעלות פרמטרים פורמליים שונים. פונקציות אלו נקראות פונקציות חופפות, והקומפיילר מתייחס אליהן כאל פונקציות נפרדות. לדוגמא: void func1(char c) cout << "Char: " << c << endl; void func1(char *sz) cout << "String: " << sz << endl; func1("hello"); func1('w'); String: Hello Char: W התוכנית תדפיס: בקריאה הראשונה לפונקציה העברנו לה מחרוזת, לכן נקראה הפונקציה המטפלת בסוג הנתונים *.char בפונקציה השניה העברנו תו, ולכן נקראה הפונקציה המקבלת.char יתכנו מקרים בהם הקומפיילר לא ידע לאיזה מהפונקציות החופפות לפנות. נביט למשל בדוגמא הבאה: void func1(float f); void func1(double d); int x = 10; func1(x); ל - התוכנית הנ"ל לא תעבור קומפילציה. כאשר מעבירים לפונקציה פרמטרים מסוג שונה מזה שהפונקציה מקבלת, מתבצעת המרה של הפרמטר הנשלח לזה שהפונקציה מצפה לקבל. אולם, במקרה לעיל הקומפיילר לא ידע להחליט לאיזה סוג משתנה להמיר את float- x או.double לפיכך, אם ננסה לקמפל את הקוד הנ"ל נקבל הודעת שגיאה שתודיע על כך. עמוד 15

16 הקצאת זיכרון דינמית אחת האפשרויות החשובות בכל שפת תכנות, היא האפשרות להקצות לתוכנית זיכרון נוסף בזמן ריצה. ב- C, השתמשנו בפונקציה malloc() על מנת להקצות זיכרון, ובפקודה free() על מנת לשחרר זיכרון זה. ב++ C, נשתמש במילים השמורות new ו- delete על מנת להקצות ולשחרר זיכרון. ה- syntax של :new ואם נרצה להקצות מערך של אלמנטים: <pointer> = new <requested type>; <pointer> = new <requested type>[number of items]; למשל, נניח שנרצה להקצות משתנה מסוג,int נכתוב: אם נרצה להקצות מחרוזת באורך 20, נכתוב: int *pi; pi = new int; char *szstring; szstring = new char[20]; זיכרון שהוקצה באופן דינמי, יש לשחרר במפורש, על ידי.delete ה- syntax של :delete ובמקרה שנרצה לשחרר מערך שהוקצה: delete <pointer>; delete []<pointer>; למשל, על מנת לשחרר את הזיכרון אותו הקצנו בדוגמא הקודמת בעזרת,new נכתוב: delete pi; delete []szstring; עמוד 16

17 Default parameters אחת האפשרויות החדשות, שלא היו קיימות בשפת C, ששפת ++C מספקת לנו, היא האפשרות לתת ערך ברירת מחדל לפרמטרים של פונקציות. אם פרמטר כלשהו של פונקציה בדרך כלל מקבל ערך קבוע, ורק לעיתים רחוקות נרצה לשים ערך במקומו, נוכל להשתמש במנגנון זה. נביט בדוגמא הבאה: #include <iostream.h> void func1(int i = 10) cout << i << endl; func1(23); func1(); פלט התוכנית יהיה: "23" ושורה לאחר מכן "10". הפונקציה func1 מקבלת פרמטרבשם i. ערך ברירת המחדל שלו נקבע להיות 10. כאשר אנו קוראים לפונקציה עם הערך 23, אנו מדפיסים את המספר 23 על המסך ומתעלמים לגמרי מערך ברירת המחדל. כאשר אנו קוראים לפונקציה שורה לאחר מכן ללא כל פרמטר, אזי הפונקציה משתמשת בערך ברירת המחדל של i ומדפיסה על המסך 10. כאשר פונקציה מקבלת מספר ערכים, אשר לחלקם ישנה ברירת מחדל ולחלקם אין ברירת מחדל, יופיעו המשתנים ללא ברירת המחדל ראשונים. לדוגמא, הפונקציה הבאה איננה כתובה בצורה חוקית: הפונקציה הבאה הינה חוקית: void PrintNumbers(int i2 = 10, int i3 = 20, int i1) cout << i1 << " " << i2 << " " << i3 << endl; void PrintNumbers(int i1, int i2 = 10, int i3 = 20) cout << i1 << " " << i2 << " " << i3 << endl; עמוד 17

18 נביט בפונקצית ה-() main הבאה המשתמשת בפונקציה :PrintNumbers PrintNumbers(10); PrintNumbers(10, 20); PrintNumbers(10, 20, 30); PrintNumbers(); כל השורות, מלבד השורה המודגשת באדום, יעברו קומפילציה. השורה המודגשת לא תעבור קומפילציה, מכיוון שלא הגדרנו ערך ברירת מחדל ל- i1, ולכן אי אפשר לקרוא לפונקציה ללא העברת ערך אליו. פלט התוכנית ללא השורה הבעייתית: גם לפונקציות של מחלקה ניתן להגדיר ערכי ברירת מחדל. נראה זאת בהמשך המסמך עמוד 18

19 משתני התייחסות אלמנט שפה חדש נוסף בשפת ++C הוא משתני התייחסות.references ניתן לחלק את אלמנטי המידע בשפת C לשתי קטגוריות: משתנים ומצביעים. משתנה הכיל מידע, ומצביע הינו משתנה שמכיל כתובת בזכרון, בה נמצא משתנה אחר. נביט איך זה נראה בזכרון. נניח כי הגדרנו משתנה i מסוג מספר שלם. ל- i הוקצאו מספר תאים בזכרון (לצורך פשטות נניח כי הוקצה תא אחד). נניח, למשל, של- i הוקצאה הכתובת 1000 בזכרון. int i = 5; כעת נגדיר מצביע p, שיצביע אל i. מצביע הוא משתנה בעצמו, ולכן יש לו כתובת. נניח כי p קיבל את הכתובת p יצביע אל i, ולכן p יכיל את הערך int *p = &i; ++C מציגה צורת עבודה נוספת - משתני התייחסות. משתנה התייחסות הינו שם נוסף למשתנה קיים. לא יוקצה זכרון נוסף עבור משתנה ההתייחסות. שינוי של משתנה ההתייחסות ישנה את המשתנה המקורי. מבחינת תחביר, משתנה התייחסות יוגדר כך: לדוגמא: <type>& <reference_name> = var_name; int &j = i; שינוי של j יגרום לשינוי של i, ולהפך. נביט כעת בדוגמא פשוטה לשימוש במשתני התייחסות: עמוד 19

20 #include <iostream.h> int i = 5; int &j = i; j = 7; cout << i << endl; פלט התוכנית יהיה 7. משתני התייחסות יכולים להיות פרמטרים של פונקציות, וכן ערכים מוחזרים של פונקציות. יתרונות השימוש במשתני התייחסות: 1. נוחות שימוש: השימוש בהם הינו כמו במשתנה לוקלי, ולא צריך להסתבך עם התחביר של מצביעים. 2. יעילות: לא נוצר העתק של המשתנה המועבר אל הפונקציה (פעולה שיכולה להיות יקרה), אלא ממש המשתנה מועבר. נשים לב כי לאחר שהגדרנו את j להתייחס אל i, לא ניתן לגרום לו להתייחס למשתנה אחר. שינוי של j ישנה את הערך שהוא מתייחס אליו. כלומר: הקביעה לאן מתייחס ה- reference נקבעת עם אתחולו. משתנה התייחסות הינו שם נוסף למשתנה קיים. לא מוקצה עבורו עוד זכרון. #include <iostream.h> int i = 5; int &j = i; cout << &i << endl << &j << endl; פלט התוכנית יכול להיות, למשל: 0x0012FF7C 0x0012FF7C עמוד 20

21 הגדרת משתנים, Constructors & Destructors ADT הינה אחת מדרכי התכנות השימושיות ביותר בשפת C. עם זאת, כבר ציינו שבשפת C היו בגישה זו מספר בעיות. נציג כעת בעיה נוספת, ונראה כיצד ++C פותרת אותה. כפי שכבר צוין, הרעיון שמאחורי ADT הוא הגדרת מבנה נתונים (struct) ופעולות (פונקציות) שפועלות עליו. דוגמא ל- ADT בשפת C היא מנגנון העבודה עם קבצים בשפת C. הגדרנו struct בשם.FILE כאשר היינו רוצים לגשת לקובץ, היינו ראשית מצהירים על מצביע מסוג.FILE לאחר מכן, היינו משתמשים בפעולה fopen על מנת לפתוח את הקובץ. היינו מבצעים פעולות קלט פלט שונות, ובסיום העבודה היינו סוגרים את הקובץ עם הפקודה.fclose באופן דומה, לכל ADT בשפת C, יצרנו פונקציות "Create" ו-" Destroy " ששימשו לאתחול והריסת מבנה הנתונים. תהליך זה, של יצירת מצביע, איתחולו בעזרת פונקציה ומחיקתו בסיום על ידי פונקציה אחרת אינו בטוח. נביט בדוגמא הבאה כדי לראות למה: נניח שנתונה התוכנית הבאה: #include <stdio.h> FILE *fin; char szfilename[20]; printf("enter file name: "); scanf("%s", szfilename); fin = fopen(szfilename, "r");... fclose(fin); למתכנתי C, תוכנית זו נראית תקינה, אולם היא מכילה מצב שב++ C אנו מנסים להימנע ממנו: אנו מגדירים את המצביע fin כבר בשורה הראשונה של הפונקציה, אולם אנו שמים בו ערך משמעותי רק עמוק בתוך הפונקציה. הבעייתיות במצב זה שאם יוסף קוד בין הרגע שהצהרנו על fin עד לרגע שאתחלנו את המשתנה, אזי נקבל זבל. נרצה למנוע את קיומם של משתנים או אובייקטים לא מאותחלים. הגישה של ++C: בתוכנית ++C הבנויה כראוי, בכל רגע נתון כל המשתנים מכילים ערכים תקפים (ערכים אלו יכולים להיות גם NULL או ערך שיאמר שאין במשתנה מידע משמעותי, אולם לא יהיו משתנים שיכילו זבל). האמצעים לעמוד בדרישה זו: הגדרת משתנים בכל מקום בפונקציה. ו- Destructors. Constructors עמוד 21

22 הגדרת משתנים בשפת ++C, אנו יכולים להגדיר משתנים בכל קטע של הפונקציה, ולא רק בראש בלוק. אי לכך, נוכל להגדיר על המשתנה, מיד לפני שנרצה להשתמש בו, ולאו דווקא בראש הפונקציה. למשל, התוכנית הבאה היא תוכנית חוקית לגמרי ב++ C, אולם לא ב- C : printf("please enter 2 numbers: "); int x, y; scanf("%d%d", &x, &y); int sum = x+y; printf("the sum of x+y is %d\n", sum); למרות שזו תוכנית חוקית ב++ C, נזכור כי אמרנו שב++ C נשתמש בפונקציות הקלט והפלט של ++C, ולא באלו של שפת C, ולכן הדרך הנכונה לכתוב את התוכנית הינה: cout << "Please enter 2 numbers: "; int x, y; cin >> x >> y; int sum = x+y; cout << "The sum of x+y is " << sum << endl; על ידי כך שאנו מגדירים את המשתנים קרוב ככל הניתן למקום בו אנו משתמשים בהם, התקדמנו צעד לעבר המצב הרצוי לנו - המשתנים מצויים כעת זמן מינימלי במצב לא מאותחל. אנו מגדירים אותם רגע לפני שאנו ממלאים בהם תוכן, ולכן הסיכוי שנשתמש במשתנה בו יש זבל קטן, אם זאת, עדיין לא הגענו למצב שבכלל אין משתנים המכילים זבל. נביט כעת כיצד אנו פותרים בעיה זו. Constructors & Destructors תחביר בסיסי ומוטיבציה לכל מחלקה, ישנן מספר פונקציות מיוחדת - הבנאים (Constructors).(Destructor) וההורסים מבחינת תחביר, הבנאי הוא פונקציה ששמה כשם המחלקה. הבנאי יכול לקבל פרמטרים כלשהם כרצוננו. ההורס הוא פונקציה ששמה מתחיל ב~ (גל), ולאחריו שם המחלקה. ההורס אינו מקבל לעולם פרמטרים. עמוד 22

23 למשל, נביט במחלקה הבאה. שם המחלקה הוא,MyClass ויש לה בנאי והורס, ששניהם אינם מקבלים פרמטרים: class MyClass MyClass(); ~MyClass(); ; הבנאי וההורס נמצאים לרוב בחלק ה- public של המחלקה. ניתן לשים אותם גם תחת הרשאה אחרת, אולם הרווחים מפעולה כזו הם מחוץ להיקפו של מסמך זה. אנו נניח כי תמיד הבנאי וההורס נמצאים תחת הרשאה.public הבנאי היא פונקציה הנקראת ברגע שאובייקט מסוג המחלקה נוצר. מטרת פונקציה זו היא לאתחל את שדות האובייקט בערכים התחלתיים, ולבצע פעולות אתחול נוספות אם יש צורך בכך. למשל, נביט בקטע הקוד הבא: class Rectangle private: int x, y; Rectangle(); Rectangle::Rectangle() x = y = 4; cout << "Rectangle Ctor" << endl; Rectangle x1; cout << "Main Program" << endl; Rectangle x2; יצרנו מחלקה בשם Rectangle (מלבן). הגדרנו במחלקה זו את השדות x ו- y, שהם שדות פרטיים של המחלקה. הבנאי של המחלקה מאתחל את x,y ושם בהם את הערך 4. כאשר נריץ את התוכנית, על המסך יודפס: Rectangle Ctor Main Program Rectangle Ctor מיד כאשר הצהרנו על אובייקט של המחלקה, נקרא הבנאי על מנת לאתחל את השדות שלו. עמוד 23

24 ההורס של המחלקה נקרא רגע לפני שהזיכרון שהוקצה עבור אובייקט כלשהו משתחרר. אם נרצה לעשות פעולות שונות לפני שחרור הזיכרון של האובייקט, נבצע אותן כאן. למשל, נניח שאחת מהפונקציות של המחלקה הקצתה זיכרון דינמי במהלך ריצת התוכנית, ונרצה לשחרר זיכרון זה, לפני שנשחרר את זיכרון המחלקה. ניקח כעת את הגדרת המחלקה Rectangle ונוסיף לה :Destructor class Rectangle private: int x, y; Rectangle(); ~Rectangle(); Rectangle::Rectangle() x = y = 4; cout << "Rectangle Ctor" << endl; Rectangle::~Rectangle() cout << "Rectangle Dtor" << endl; נביט כעת במספר תוכנית, שיתייחסו כולן למימוש זה של :Rectangle ראשית נביט באותה דוגמא שראינו קודם, טרם הוספנו את ההורס ל- Rectangle. Rectangle x1; cout << "Main Program" << endl; Rectangle x2; Rectangle Ctor Main Program Rectangle Ctor Rectangle Dtor Rectangle Dtor כעת תוכנית זו תדפיס: שלושת השורות הראשונות הן אותן שלושת השורות שהיו בדוגמא הקודמת. בסוף הפונקציה,main() משוחררים כל המשתנים המקומיים שהוקצו בה. מכיוון ש- x2,x1 הינם משתנים מקומיים, הם משוחררים, ורגע לפני שהם משוחררים נקרא ההורס שלהם. עמוד 24

25 נביט בדוגמא שניה: Rectangle x1, *x2; cout << "Stage 1" << endl; x2 = new Rectangle; x1 = *x2; delete x2; cout << "Final stage" << endl; על המסך יודפס: Rectangle Ctor Stage 1 Rectangle Ctor Rectangle Dtor Final stage Rectangle Dtor כאשר הגדרנו את x1 ואת x2, נקרא הבנאי רק פעם אחת, רק עבור x1. x1 הוא אובייקט מסוג,Rectangle ולכן אתחלנו אותו. x2 הוא מצביע, והוא איננו אובייקט של המחלקה (הוא רק מצביע אל אחד כזה) ולכן אין צורך לקרוא לבנאי עבור x2. כאשר הקצנו זיכרון דינמי, נקרא הבנאי על מנת להקצות את הזיכרון החדש שהוקצה. תופעה זו היא אחת החידושים של הפקודה,new לעומת הפקודה malloc() של C. זיכרון שהוקצה על ידי malloc() לא יאותחל (לא יקרא הבנאי בצורה אוטומטית). לעומת זאת, אם אנו מקצים זיכרון בעזרת,new נקרא הבנאי של המחלקה. הפקודה,delete בצורה דומה, קראה להורס של Rectangle כדי לבצע פעולות ניקוי רגע לפני ששוחרר הזיכרון של האובייקט. בסוף הפונקציה main() שוחרר x1, שהוא משתנה מקומי. כיצד בנאים עוזרים לנו לעמוד בעקרונות של ++C, שקודם דיברנו עליהם? ניזכר במטרה אותה רצינו להשיג: בתוכנית ++C הבנויה כראוי, בכל רגע נתון כל המשתנים מכילים ערכים תקפים. כבר ראינו שהגדרת משתנים רגע לפני שמשתמשים בהם, מצמצמת למינימום את הזמן שיש באובייקטים זבל. בנאים עושים יותר מכך - ברגע שאובייקט נוצר, נקרא הבנאי שלו, שתפקידו לאתחל את השדות השונים באובייקט. אם נכתוב את הבנאי כראוי, נוכל להבטיח שכל אובייקט מהמחלקה שאנו כותבים, יהיה מאותחל בכל רגע. בתוכנית ++C, האובייקטים השונים יוגדרו כאשר יהיה צריך להשתמש בהם. מיד עם ההצהרה עליהם, הם יאותחלו ללא התערבות המתכנת המשתמש באובייקט, על ידי הבנאים. עמוד 25

26 מחלקות בעלות מספר בנאים, רשימות אתחול נחדד כעת מספר נקודות הקשורות לבנאים, ולדרכים בהן כותבים אותם ומשתמשים בהם. נביט בדוגמא הבאה. אנו נשפר דוגמא זו בהדרגה בעמודים הבאים: #include <iostream.h> class myclass private: int p_i, p_j; myclass(); myclass(int i, int j); ; int GetI() return p_i; // Constructors Implematation: (first way) myclass::myclass() p_i = p_j = 0; myclass::myclass(int i, int j) p_i = i; p_j = j; myclass my1; cout << my1.geti() << endl; // Will print 0 (default constructor was called) myclass my2(6, 4); cout << my2.geti() << endl; // Will print 6 (second constructor was called) למחלקה myclass ישנם שני בנאים: myclass(); myclass(int i, int j); כאן אנו רואים שלמחלקה יכול להיות יותר מבנאי אחד. אלו למעשה פונקציות חופפות, אותן כבר ראינו. עמוד 26

27 כאשר יצרנו את האובייקט,my1 נקרא הבנאי ללא הפרמטרים. במקרה זה לא העברנו אף פרמטר למחלקה. לעומת זאת, כאשר יצרנו את האובייקט,my2 יצרנו אותו כך: myclass my2(6, 4); הערכים שבסוגריים הם הערכים שמועברים אל הבנאי המתאים. במקרה זה יקרא הבנאי המקבל שני מספרים שלמים. לעומת הבנאי, ההורס הוא פונקציה שאיננה מקבלת פרמטרים אף פעם, ולפיכך ההורס הוא יחיד. נשתמש במספר בנאים כאשר נרצה לאתחל אובייקטים במספר דרכים - למשל, נניח שנרצה ליצור מחלקה שמטפלת באורכים - נוכל לכתוב בנאי שיקבל,int לכתוב בנאי אחר שיקבל double וכו', וכך לגרום למחלקה שלנו להיות מאותחלת על ידי סוגים שונים של ערכים. נביט כרגע במימוש נוסף של אותה מחלקה: #include <iostream.h> class myclass private: int p_i, p_j; myclass(); myclass(int i, int j); int GetI() return p_i; ; // Constructors Implematation: (second way) myclass::myclass() : p_i(0), p_j(0) // Will be the same as writing inside the constractor: // p_i = 0; p_j = 0; -- but this way is faster and recommended myclass::myclass(int i, int j) : p_i(i), p_j(j) myclass my1; cout << my1.geti() << endl; myclass my2(6, 4); cout << my2.geti() << endl; כאן אנו משתמשים ברשימת אתחול בבנאי. נביט בצורה בה הבנאי מומש: myclass::myclass(int i, int j) : p_i(i), p_j(j) עמוד 27

28 מיד לאחר הצהרת הבנאי, ולפני הסוגריים המסולסלות, מופיעה רשימת האתחול של הבנאי. אנו מתחילים את רשימת האתחול ב":" (נקודותיים). לאחר מכן, כאשר אנו כותבים,p_i(i) אנו אומרים "אתחל את המשתנה p_i לערך i. כל הפעולות שנבצע ברשימת האתחול יתרחשו לפני הכניסה לגוף הבנאי (הבלוק שבתוך הסוגריים המסולסלות). מימוש זה זהה בפעולתו למימוש הקודם, אולם הוא מהיר יותר, ונחשב לתכנות נכון יותר ב++ C. כפי שאנו רואים בשורה הבאה, ניתן לאתחל משתנים לא רק על ידי משתנים אחרים, אלא גם על ידי קבועים: myclass::myclass() : p_i(0), p_j(0) נביט כעת בשיפור נוסף ואחרון לתוכנית קצרה זו. #include <iostream.h> class myclass private: int p_i, p_j; myclass(int i=0, int j=0) : p_i(i), p_j(j) int GetI() return p_i; ; myclass my1; cout << my1.geti() << endl; myclass my2(6, 4); cout << my2.geti() << endl; בדוגמא זו איחדנו את שני הבנאים לבנאי אחד, בעזרת שימוש במנגנון ה Default parameters של ++C. כאשר יצרנו אובייקט ללא פרמטרים, נלקחו ערכי ברירת המחדל בתור הערכים לאתחול האובייקט, וכאשר נתנו ערכים מפורשים, ++C השתמשה בהם כדי לאתחל את האובייקט החדש. לכל פונקציה (פרט לDestructor של מחלקה, שהינו פונקציה חסרת פרמטרים) נוכל להגדיר ערכי ברירת מחדל. בפרט נוכל להגדיר ערכי ברירת מחדל לכל פרמטר בפונקציה של מחלקה, וכן גם לבנאי שלה. בזאת סיימנו עם שיפור הדוגמא הראשונה הקשורה לבנאים. נעבור למספר דוגמאות נוספות, ונציג בהן נקודות נוספות הקשורות לבנאים. עמוד 28

29 Default Constructor לכל מחלקה ב++ C קיים בנאי, בין אם אנו כותבים אחד כזה במפורש, ובין אם לא. נניח למשל שניצור את המחלקה הבאה: class MyClass אם לא נצהיר על בנאי במפורש, ++C תוסיף בזמן הקומפילציה בנאי ברירת מחדל ;.(Default Constructor) הבנאי יהיה בנאי ריק, שלא יבצע כלום, והוא זהה למעשה למחלקה בה קיימת ההצהרה הבאה: MyClass::MyClass() אם נממש בנאי משלנו למחלקה, ++C לא תוסיף למחלקה את בנאי ברירת המחדל. נביט בקוד הבא: class Man private: char *szname; Man(const char *name); ; Man person("nir"); Man no_one; בדוגמא זו, השורה באדום לא תעבור קומפילציה. מכיוון שמימשנו בנאי למחלקה, ++C לא תוסיף למחלקה בנאי ללא פרמטרים, ולכן אי יהיה אפשר ליצור אובייקט בלי לאתחל אותו. ניתן לאמר שבדוגמא זאת מימשנו את הרעיון - "לכל אדם יש שם". ++C לא תיתן לנו להגדיר משתנה מסוג אדם, אם לא ניתן לו שם. באופן דומה, נביט בדוגמא הבאה: class MyClass1 MyClass1(int i); ; class MyClass2 עמוד 29

30 ; MyClass2(); class MyClass3 ; MyClass1 m[100]; /* Illegal */ MyClass2 m1[100]; /* Legal */ MyClass3 m2[100]; /* Legal too - MyClass3 has default constructor that doesn't get any parameters */ השורה המודגשת באדום לא תעבור קומפילציה. כאשר אנו יוצרים מערך, נקרא הבנאי עבור האובייקטים השונים שאנו יוצרים. מכיוון שאנו לא מסוגלים (מבחינת תחבירית) להגדיר את הערכים שיעברו אל הבנאי, כאשר אנו יוצרים מערכים תמיד יקרא בנאי ברירת המחדל, או הבנאי ללא פרמטרים אם הגדרנו כזה. לפיכך, לא ניתן ליצור מערכים של אובייקטים ממחלקות שיש להן רק בנאים בעלי פרמטרים. נביט בדוגמא נוספת הקשורה למערכים. מה תדפיס התוכנית הבאה? #include <iostream.h> class A A() cout << "A"; ; A blah[100]; cout << "Hello World!!!" << endl; התשובה: התוכנית תדפיס את התו A מאה פעמים, ולאחריו ייכתב World!!!.Hello עבור כל איבר ואיבר במערך, נקרא הבנאי. הבנאי נקרא עבור כל איבר במערך, על מנת שכל התאים במערך יכילו עצמים תקפים מסוג A. עמוד 30

31 דוגמא מסכמת לאחר שראינו את נושא הבנאים מכיוונים שונים, נציג תוכנית דוגמא שתסכם את רוב הנושאים שראינו במסמך זה. נציג כעת את המטרה אליה נגיע בתוכנית, ונבנה את התוכנית בשלבים, פונקציה אחר פונקציה. דוגמא זו באה להציג כיצד יש לגשת למימוש מחלקה פשוטה ב++ C. בדוגמא זו נרצה ליצור מחלקה שתייצג בני אדם. לכל בן אדם יש שם, והמחלקה תאפשר לקבל את שמו של בן אדם כלשהו, או להחליף לו את שמו. נביט בהצהרה על המחלקה: class Person char *Name; Person(const char *szname); ~Person(); void print(); void SetName(const char *sznewname); const char *GetName() const; ; הגדרנו שדה מסוג char* בשם,Name שיכיל את שמו של האדם. הבנאי יתאחל שדה זה, הפונקציה GetName() תחזיר לקורא לה את שמו של האדם, והפונקציה SetName() תאפשר לנו לקבוע לאדם שם חדש. הפונקציה Print() תדפיס את שמו של האדם על המסך. נתחיל במימוש הבנאי. על הבנאי להקצות זיכרון עבור,Name ולהעתיק אל Name את המחרוזות אותה הוא מקבל כפרמטר. לכן, נממש את הבנאי בצורה הבאה: Person::Person(const char *szname) Name = new char[strlen(szname)+1]; strcpy(name, szname); ראשית הקצנו זיכרון עבור שמו של האדם (פלוס 1 עבור התו '0\' המסיים את המחרוזת). לאחר מכן העתקנו את המחרוזת הנתונה כפרמטר אל.Name מימוש הפונקציה Print() הוא טריוויאלי. נדפיס את ערכו של Name אל הפלט הסטנדרטי: void Person::print() cout << "My Name: " << Name << endl; עמוד 31

32 גם מימוש הפונקציה GetName() איננו קשה במיוחד. הפונקציה פשוט מחזירה את ערכו של :Name const char *Person::GetName() const return Name; ההורס של המחלקה צריך לשחרר את הזיכרון הדינמי שהקצנו עבור :Name Person::~Person() delete[] Name; מכיוון שהקצנו מערך של,char נשתמש ב- delete[] על מנת לשחרר אותו. עד כה, ראינו נקודות פשוטות, אך חשובות, כאשר אנו יוצרים מחלקה, המשתמשת בזיכרון דינמי. נביט כעת בפונקציה המעניינת ביותר במחלקה,.SetName() מהן הפעולות שעל פונקציה זו לבצע? ראשית, נזכור שאנו עובדים ב++ C, ולכן אנו מניחים כי האובייקט נמצא כל העת במצב תקין, מאותחל. ומכאן: כאשר קוראים לפונקציה,SetName() מוקצה כרגע כבר זיכרון עבור השם הקודם. גישה נאיבית תאמר כעת: הזיכרון כבר מוקצה, ולכן אין צורך להקצות שוב זיכרון, לכן רק נעתיק את המחרוזת החדשה במקום המחרוזת הישנה, ונסיים את הפונקציה. למשל, נוכל לממש גישה זו בצורה הבאה: void Person::SetName(const char *sznewname) strcpy(name, sznewname); פתרון זה איננו נכון! איננו מתייחסים כאן לעובדה, כי יכול להיות שהשם החדש אותו נרצה לתת לאדם, הינו בגודל שונה מהשם הישן שלו. אם השם החדש קטן מהשם הישן, לא תהיה בעיה במימוש, מלבד העובדה שמעט מהזיכרון שהקצנו יישאר מוקצה אך ללא שימוש מעשי. אם השם החדש גדול מהשם הישן, תתרחש דליפת זיכרון. לפיכך, הגישה הנכונה תהיה ראשית לשחרר את הזיכרון שהקצנו עבור השם הישן, ואז להקצות זיכרון לשם החדש. עמוד 32

33 להלן מימוש נכון של הפונקציה :SetName() void Person::SetName(const char *sznewname) delete[] Name; Name = new char[strlen(sznewname) + 1]; strcpy(name, sznewname); ראשית אנו משחררים את הזיכרון הישן, ואז אנו מקצים זיכרון חדש בגודל הרצוי ומציבים אותו במשתנה.Name #include <iostream.h> #include <string.h> לסיום, נציג את המחלקה שבנינו בשלמותה: class Person char *Name; Person(const char *szname) Name = new char[strlen(szname)+1]; strcpy(name, szname); cout << "ctor" << endl; void print() cout << "MyName: " << Name << endl; ~Person() delete[] Name; void SetName(const char *sznewname) delete[] Name; Name = new char[strlen(sznewname) + 1]; strcpy(name, sznewname); ; const char *GetName() const return Name; עמוד 33

34 סיום מסמך זה מגיע אל סיומו. במסמך זה סקרנו בקצרה את הנושאים הבסיסיים ביותר בשפת ++C, אולם ל-++ C יש הרבה יכולות להציע מעבר לאלו שראינו במסמך זה, ואף הנושאים שהוצגו במסמך זה, לא מוצו עד תום. לסיום המסמך, נציג דוגמא אחרונה, ללא הסברים רבים, שתציג את אחת התכונות החשובות ב++ C - הורשה. רעיון ההורשה הוא אחד הרעיונות החזקים ביותר של ++C: לאחר שהגדרנו מחלקה, נרצה להשתמש בה גם במחלקות אחרות. דרך אחת הינה להגדיר אובייקט מסוג מחלקה אחת בתוך מחלקה אחרת. אולם, לפעמים נרצה להגדיר מחלקה אחת, ולאחר מכן להגדיר מחלקה שניה, שהיא מקרה פרטי של המחלקה הראשונה. לדוגמא: לאחר שהגדרנו בדוגמא הקודמת את המחלקה "בן אדם", יתכן שנרצה להגדיר עכשיו את המחלקה "זמר". "זמר" הוא בפרט "בן אדם", וכולל את כל התכונות של "בן אדם". בנוסף לכך הוא כולל תכונה נוספת. "זמר" יודע לשיר. ++C נותנת לנו אפשרות להגדיר מחלקה נוספת - שתקבל את כל המשתנים והפונקציות (עם הגבלות מסוימות) של המחלקה המקורית, וכך לא נצטרך לממשם שוב עבור המחלקה השניה. נציג דוגמת קוד לכך: נרצה לממש מחלקה שתייצג מלבן, ושתוכל להדפיס מלבן על המסך, וכן לחשב את שיטחו של המלבן. לאחר מכן נממש בעזרתה מחלקה מסוג ריבוע, שהוא מקרה פרטי של מלבן. להלן מימוש מחלקת המלבן: #include <iostream.h> class myrectangle int Area(); void SetX(int vx) if (vx >= 0) m_x = vx; void SetY(int vy) if (vy >= 0) m_y = vy; void Print(); myrectangle(int x, int y) : m_x(x), m_y(y) ~myrectangle() private: int m_x, m_y; ; int myrectangle::area() return m_x * m_y; עמוד 34

35 // Function that prints the Rectangle on the screen void myrectangle::print() for (int x = 0; x < m_x; ++x) for (int y = 0; y < m_y; ++y) cout<<'*'; cout<<endl; // New line at the end of the shape cout<<endl; פרטי המימוש של המחלקה אינם מסובכים, והקורא יוכל לעמוד על הדקויות בהן לבדו. נממש כעת את המחלקה ריבוע, שתיגזר (תקבל את כל התכונות) של המחלקה מלבן. על מנת לציין שהמחלקה ריבוע נגזרת מהמחלקה מלבן, נצהיר על המחלקה ריבוע כך: class Square : public myrectangle בצורה כזו המחלקה קיבלה את המתודות והשדות השונים של מחלקת המלבן. כאשר אנו כותבים,public myrectangle אנו אומרים כי כל שדות ה- public של המחלקה,myRectangle יהיו גם בשדות ה- public של המחלקה.Square אם היינו כותבים,private myrectangle היינו אומרים כל שדות ה- public של המחלקה,myRectangle יהפכו להיות שדות private במחלקה.Square לרוב נשתמש ב- public כאשר נגזור מחלקה ממחלקה. להלן מימוש המחלקה: class Square : public myrectangle Square(int x) : myrectangle(x, x) ; void SetX(int vx) myrectangle::setx(vx); myrectangle::sety(vx); void SetY(int vy) SetX(vY); עמוד 35

36 נשים לב למספר דברים חדשים במימוש זה: הבנאי הוגדר בצורה הבאה: Square(int x) : myrectangle(x, x) משמעות כתיבה זו: הבנאי של Square קורא לבנאי של,myRectangle ומעביר לו את הפרמטרים,x. x void Square::SetX(int vx) myrectangle::setx(vx); myrectangle::sety(vx); אנו מממשים מחדש עבור הריבוע את הפונקציות SetX() ו-() SetY, מכיוון שבריבוע, שינוי אורך צלע גורר שינוי אורך של כל הצלעות. כאשר אנו כותבים את הביטוי myrectangle::setx(vx) בתוך הפונקציה, אנו למעשה אומרים ל++ C להשתמש בפונקציה SetX() שירשנו מהמחלקה,myRectangle ולא לקרוא לפונקציה SetX() שמוגדרת מחדש במחלקה.Square נדגים כעת שימוש בתוכנית: myrectangle myrec(5, 4); myrec.print(); Square mysqr(7); mysqr.print(); mysqr.setx(2); mysqr.print(); cout << "Square Area is : " << mysqr.area() << endl; כעת אנו רואים את יתרון תכונת ההורשה של ++C בבירור. את הפונקציות Area() ו-() Print לא מימשנו במפורש עבור הריבוע, אולם מנגנון ההורשה מאפשר לנו להשתמש בפונקציות אלו, השייכות למלבן. בצורה זו, חסכנו לעצמנו כתיבה. מימשו במחלקה ריבוע רק את הפונקציות הקשורות ספציפית לריבוע, ולא למלבן, ואת כל השאר קיבלנו בצורה שקופה מהמלבן. -EOF- עמוד 36